/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "app_version.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

/* USER CODE END Variables */
osThreadId ioTaskHandle;
uint32_t ioTaskBuffer[ 256 ];
osStaticThreadDef_t ioTaskControlBlock;
osThreadId rangeTaskHandle;
uint32_t rangeTaskBuffer[ 256 ];
osStaticThreadDef_t rangeTaskControlBlock;
osThreadId presTaskHandle;
uint32_t presTaskBuffer[ 256 ];
osStaticThreadDef_t presTaskControlBlock;
osThreadId cat1TaskHandle;
uint32_t lteTaskBuffer[ 300 ];
osStaticThreadDef_t lteTaskControlBlock;
osThreadId HMITaskHandle;
uint32_t HMITaskBuffer[ 128 ];
osStaticThreadDef_t HMITaskControlBlock;
osThreadId voltageTaskHandle;
uint32_t voltTaskBuffer[ 256 ];
osStaticThreadDef_t voltTaskControlBlock;

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartIOTask(void const * argument);
void dw_main(void const * argument);
void StartPresTask(void const * argument);
void StartCAT1Task(void const * argument);
void StartHMITask(void const * argument);
void StartVoltageTask(void const * argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* GetIdleTaskMemory prototype (linked to static allocation support) */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );

/* GetTimerTaskMemory prototype (linked to static allocation support) */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize );

/* Hook prototypes */
void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName);
void vApplicationMallocFailedHook(void);

/* USER CODE BEGIN 4 */
__weak void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName)
{
   /* Run time stack overflow checking is performed if
   configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook function is
   called if a stack overflow is detected. */
	PRINT(pcTaskName);
	PRINT(" stack overflow\r\n");
	Error_Handler();
}
/* USER CODE END 4 */

/* USER CODE BEGIN 5 */
__weak void vApplicationMallocFailedHook(void)
{
   /* vApplicationMallocFailedHook() will only be called if
   configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook
   function that will get called if a call to pvPortMalloc() fails.
   pvPortMalloc() is called internally by the kernel whenever a task, queue,
   timer or semaphore is created. It is also called by various parts of the
   demo application. If heap_1.c or heap_2.c are used, then the size of the
   heap available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in
   FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used
   to query the size of free heap space that remains (although it does not
   provide information on how the remaining heap might be fragmented). */
	volatile size_t freesize = xPortGetFreeHeapSize();
//	size_t minisize = xPortGetMinimumEverFreeHeapSize();
	PRINT("malloc failed\r\n");
	Error_Handler();
}
/* USER CODE END 5 */

/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */
static StaticTask_t xIdleTaskTCBBuffer;
static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
{
  *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;
  *ppxIdleTaskStackBuffer = &xIdleStack[0];
  *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
  /* place for user code */
}
/* USER CODE END GET_IDLE_TASK_MEMORY */

/* USER CODE BEGIN GET_TIMER_TASK_MEMORY */
static StaticTask_t xTimerTaskTCBBuffer;
static StackType_t xTimerStack[configTIMER_TASK_STACK_DEPTH];

void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize )
{
  *ppxTimerTaskTCBBuffer = &xTimerTaskTCBBuffer;
  *ppxTimerTaskStackBuffer = &xTimerStack[0];
  *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
  /* place for user code */
}
/* USER CODE END GET_TIMER_TASK_MEMORY */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* definition and creation of ioTask */
  osThreadStaticDef(ioTask, StartIOTask, osPriorityHigh, 0, 256, ioTaskBuffer, &ioTaskControlBlock);
  ioTaskHandle = osThreadCreate(osThread(ioTask), NULL);

#ifndef PRESSURE_STATION
  /* definition and creation of rangeTask */
  osThreadStaticDef(rangeTask, dw_main, osPriorityAboveNormal, 0, 256, rangeTaskBuffer, &rangeTaskControlBlock);
  rangeTaskHandle = osThreadCreate(osThread(rangeTask), NULL);
#endif

  /* definition and creation of presTask */
  osThreadStaticDef(presTask, StartPresTask, osPriorityNormal, 0, 256, presTaskBuffer, &presTaskControlBlock);
  presTaskHandle = osThreadCreate(osThread(presTask), NULL);

  /* definition and creation of cat1Task */
  osThreadStaticDef(cat1Task, StartCAT1Task, osPriorityNormal, 0, 300, lteTaskBuffer, &lteTaskControlBlock);
  cat1TaskHandle = osThreadCreate(osThread(cat1Task), NULL);

  /* definition and creation of HMITask */
  osThreadStaticDef(HMITask, StartHMITask, osPriorityLow, 0, 128, HMITaskBuffer, &HMITaskControlBlock);
  HMITaskHandle = osThreadCreate(osThread(HMITask), NULL);

  /* definition and creation of voltageTask */
  osThreadStaticDef(voltageTask, StartVoltageTask, osPriorityNormal, 0, 256, voltTaskBuffer, &voltTaskControlBlock);
  voltageTaskHandle = osThreadCreate(osThread(voltageTask), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartIOTask */
/**
  * @brief  Function implementing the ioTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartIOTask */
__weak void StartIOTask(void const * argument)
{
  /* USER CODE BEGIN StartIOTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartIOTask */
}

/* USER CODE BEGIN Header_dw_main */
/**
* @brief Function implementing the rangeTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_dw_main */
__weak void dw_main(void const * argument)
{
  /* USER CODE BEGIN dw_main */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END dw_main */
}

/* USER CODE BEGIN Header_StartPresTask */
/**
* @brief Function implementing the presTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartPresTask */
__weak void StartPresTask(void const * argument)
{
  /* USER CODE BEGIN StartPresTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartPresTask */
}

/* USER CODE BEGIN Header_StartCAT1Task */
/**
* @brief Function implementing the cat1Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartCAT1Task */
__weak void StartCAT1Task(void const * argument)
{
  /* USER CODE BEGIN StartCAT1Task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartCAT1Task */
}

/* USER CODE BEGIN Header_StartHMITask */
/**
* @brief Function implementing the HMITask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartHMITask */
__weak void StartHMITask(void const * argument)
{
  /* USER CODE BEGIN StartHMITask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartHMITask */
}

/* USER CODE BEGIN Header_StartVoltageTask */
/**
* @brief Function implementing the voltageTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartVoltageTask */
__weak void StartVoltageTask(void const * argument)
{
  /* USER CODE BEGIN StartVoltageTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartVoltageTask */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
